home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 1995 March / macformat-022.iso / Shareware City / Developers / ANSI folder / INTO Runtime ƒ / C++ 68K ƒ / Sources ƒ / OldNew68K.cp < prev   
Encoding:
Text File  |  1994-07-08  |  6.4 KB  |  215 lines  |  [TEXT/MMCC]
  1. /************************************************************************/
  2. /*    Project...:    Standard C++ Library                                    */
  3. /*    Name......:    New.cp                                                    */
  4. /*    Purpose...:    standard C++ library                                    */
  5. /*  Copyright.: ©Copyright 1994 by metrowerks inc. All rights reserved. */
  6. /************************************************************************/
  7.  
  8. #include <new.h>
  9. #include <Memory.h>
  10.  
  11. #pragma a6frames on
  12.  
  13. #define NEWMODE_NONE    0            //    do not define operator new/delete
  14. #define NEWMODE_SIMPLE    1            //    call NewPtr/DisposPtr
  15. #define NEWMODE_NORMAL    2            //    regular new/delete
  16.  
  17. #define NEWMODE NEWMODE_NORMAL        //    mode used to compile this file
  18.  
  19.         // These macros are allow DebugNew.cp to redefine operators
  20.         // new and delete in debug mode while not adding any overhead
  21.         // for the non-debug case.
  22.  
  23. #ifndef OPERATOR_NEW
  24. #define OPERATOR_NEW operator new
  25. #endif
  26. #ifndef OPERATOR_DELETE
  27. #define OPERATOR_DELETE operator delete
  28. #endif
  29.  
  30. extern void (*new_handler)();
  31.  
  32. #if NEWMODE==NEWMODE_SIMPLE
  33.  
  34. /************************************************************************/
  35. /*    Purpose..:     Allocate memory                                            */
  36. /*    Input....:    size of memory to allocate                                */
  37. /*    Return...:    pointer to memory or 0L                                    */
  38. /************************************************************************/
  39. void *OPERATOR_NEW(size_t size,void *p)
  40. {
  41.     return p;
  42. }
  43.  
  44. /************************************************************************/
  45. /*    Purpose..:     Allocate memory                                            */
  46. /*    Input....:    size of memory to allocate                                */
  47. /*    Return...:    pointer to memory or 0L                                    */
  48. /************************************************************************/
  49. void *OPERATOR_NEW(size_t size)
  50. {
  51.     void *ptr;
  52.  
  53.     while((ptr=NewPtr(size))==NULL)
  54.     {
  55.         if(new_handler) new_handler(); else return(NULL);
  56.     }
  57.     return(ptr);
  58. }
  59.  
  60. /************************************************************************/
  61. /*    Purpose..:     Dispose memory                                            */
  62. /*    Input....:    pointer to memory or 0L (no action if 0L)                */
  63. /*    Return...:    ---                                                        */
  64. /************************************************************************/
  65. void OPERATOR_DELETE(void *ptr)
  66. {
  67.     if(ptr) DisposPtr((Ptr)ptr);
  68. }
  69.  
  70. #elif NEWMODE==NEWMODE_NORMAL
  71.  
  72. typedef struct FreeMemList {
  73.     struct FreeMemList    *next;
  74.     long                size;
  75. }    FreeMemList;
  76.  
  77. static FreeMemList    memlist;                //    dummy header block (always empty)
  78. static size_t _newpoolsize    = 0x00010000L;    //    number of bytes allocated for a new pool
  79. static size_t _newnonptrmax    = 0x00001000L;    //    any object bigger than this will call NewPtr(...) directly 
  80.  
  81. /************************************************************************/
  82. /*    Purpose..:     Set size of future allocation pools                        */
  83. /*    Input....:    size of future allocation pools                            */
  84. /*    Return...:    ---                                                        */
  85. /************************************************************************/
  86. void _set_newpoolsize(size_t size)
  87. {
  88.     _newpoolsize=size;
  89. }
  90.  
  91. /************************************************************************/
  92. /*    Purpose..:     Set NewPtr(...) pointer threshold                        */
  93. /*    Input....:    size of new threshold                                    */
  94. /*    Return...:    ---                                                        */
  95. /************************************************************************/
  96. void _set_newnonptrmax(size_t size)
  97. {
  98.     _newnonptrmax=size;
  99. }
  100.  
  101. /************************************************************************/
  102. /*    Purpose..:     Preallocate an allocation pool                            */
  103. /*    Input....:    size of pool to allocate                                */
  104. /*    Return...:    1: no error; 0:    fail                                    */
  105. /************************************************************************/
  106. char _prealloc_newpool(size_t size)
  107. {
  108.     FreeMemList    *list;
  109.  
  110.     if((list=(FreeMemList *)NewPtr(size))==NULL) return 0;
  111.     list->next=memlist.next; list->size=size; memlist.next=list;
  112.     return 1;
  113. }
  114.  
  115. /************************************************************************/
  116. /*    Purpose..:     Allocate memory                                            */
  117. /*    Input....:    size of memory to allocate                                */
  118. /*    Return...:    pointer to memory or 0L                                    */
  119. /************************************************************************/
  120. void *OPERATOR_NEW(size_t /* size */,void *p)
  121. {
  122.     return p;
  123. }
  124.  
  125. /************************************************************************/
  126. /*    Purpose..:     Allocate memory                                            */
  127. /*    Input....:    size of memory to allocate                                */
  128. /*    Return...:    pointer to memory or 0L                                    */
  129. /************************************************************************/
  130. void *OPERATOR_NEW(size_t size)
  131. {
  132.     Ptr ptr;
  133.  
  134.     size=(size&0xFFFFFFFC)+8;        //    alloc *4 quantity plus 4 extra bytes for size
  135.  
  136.     if(size>=_newnonptrmax)
  137.     {    //    try to get pointer from OS
  138.         while(1)
  139.         {
  140.             if((ptr=NewPtr(size))!=NULL) { *(long *)ptr=-1L; return(ptr+4); }
  141.             if(new_handler) new_handler(); else return(NULL);
  142.         }            
  143.     }
  144.  
  145.     while(1)
  146.     {
  147.         FreeMemList    *list,*prev;
  148.  
  149.         for(prev=&memlist,list=prev->next; list; prev=list,list=list->next) if(size<=list->size)
  150.         {
  151. alloc:        if(list->size>=size+sizeof(FreeMemList))
  152.             {    //    split this free block
  153.                 list->size-=size; ptr=(Ptr)list+list->size;
  154.                 *(long *)ptr=size; return(ptr+4);
  155.             }
  156.             //    remove this block from list
  157.             prev->next=list->next; *(long *)list=list->size; return((Ptr)list+4);
  158.         }
  159.     
  160.         //    not enough free memory in memlist (try to allocate a new Ptr from OS
  161.         if((list=(FreeMemList *)NewPtr(_newpoolsize))==NULL)
  162.         {
  163.             if(new_handler) new_handler(); else return(NULL);
  164.  
  165.             //    try to allocate a system block
  166.             if((ptr=NewPtr(size))!=NULL) { *(long *)ptr=-1L; return(ptr+4); }
  167.         }
  168.         else
  169.         {
  170.             list->next=memlist.next; list->size=_newpoolsize;
  171.             memlist.next=list; prev=&memlist; goto alloc;
  172.         }
  173.     }
  174. }
  175.  
  176. /************************************************************************/
  177. /*    Purpose..:     Dispose memory                                            */
  178. /*    Input....:    pointer to memory or 0L (no action if 0L)                */
  179. /*    Return...:    ---                                                        */
  180. /************************************************************************/
  181. void OPERATOR_DELETE(void *ptr)
  182. {
  183.     if(ptr)
  184.     {
  185.         long size;
  186.  
  187.         ptr=(Ptr)ptr-4; size=*(long *)ptr;
  188.         if(size!=-1L)
  189.         {
  190.             FreeMemList    *list,*prev;
  191.  
  192.             for(prev=&memlist,list=prev->next; list; prev=list,list=list->next)
  193.             {
  194.                 if((Ptr)ptr+size==(Ptr)list)
  195.                 {    //    merge block in front of this list item
  196.                     prev->next=list->next; size+=list->size; list=prev; continue;
  197.                 }
  198.                 if((Ptr)ptr==(Ptr)list+list->size)
  199.                 {    //    merge block at the end of this list item
  200.                     prev->next=list->next; ptr=list; size+=list->size; list=prev; continue;
  201.                 }
  202.             }
  203.         
  204.             list=(FreeMemList *)ptr; list->next=memlist.next; list->size=size; memlist.next=list;
  205.         }
  206.         else DisposPtr((Ptr)ptr);
  207.     }
  208. }
  209.  
  210. #else
  211.  
  212. //    no operator new/delete defined
  213.  
  214. #endif
  215.